﻿// ArithmeticStudy.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include<string>
#include<vector>
#include<fstream>
#include"Circle.h"
#include"Teacher.h"
#include"Manager.h"
#include"Student.h"
#include"Complex.h"

#include "Battle.h"
#include"Sensor_Sevpar.h"
#include"Sensor_PH.h"

#include "Btree.h"


using namespace std;
using std::vector;
using std::string;
using std::cin;
using std::cout;
using std::endl;
/*1、定义类时，类名称和构造函数名字相同，包含拷贝构造函数*/
/*2、构造函数可以多个，不同构造函数之间不收影响*/
/*3、私有变量只能在类内部使用，对象的所有属性都定义为私有，对外使用时，用公有的接口函数进行操作，以保证内的封装性*/
/*4、进行深拷贝时，需要单独写拷贝构造函数，以免出现IntArray类中，地址重复的错误*/
/*5、析构函数-可以用来释放内存空间，也可以用来执行最后一次调用类对象所用的任何操作，注意编写规则*/

/*1、this只能访问非静态成员对象*/
/*class A
{
    int function(int x);
};

class B
{
    friend int A::function(int x);
};//A中的函数function是B的友元函数

class B
{
    friend clsaa A;
};//类A是B的友元类，A中的所有函数可以访问B中的私有变量和受保护变量
*/

/*2、被定义的友元可以访问私有成员和保护成员
3、友元的建立有三种：
    1>普通函数定义为类的友元  格式：friend int fun();
    2>类的成员函数是另一个类的友元函数  格式：见上
    3>一个类时另一个类的友元类
*/
/*类对象的使用和初始化：和博图中F结构变量引用结构变量相似
类对象下的类的初始化：使用作用域符访问，并把大类的参数传给小类*/

//class Circle
//{
//public:
//
//    Circle()//初始化无参数类的属性
//    {
//        m_x = 0;
//        m_y = 0;
//        m_radius = 1;
//    }
//    Circle(double x, double y, double radius)//初始化有参数类的属性
//    {
//        m_x = x;
//        m_y = y;
//        m_radius = radius;
//    }
//    void SetCenter(double x, double y)//设置圆心
//    {
//        m_x = x;
//        m_y = y;
//
//    }
//    void SetRadius(double radius)//设置半径
//    {
//        m_radius = radius;
//    }
//    double  GetX()
//    {
//        return m_x;
//    }
//    double  GetY()
//    {
//        return m_y;
//    }
//    double GetRadius()
//    {
//        return m_radius;
//    }
//    double GetArea()//返回圆形的面积
//    {
//        return 3.14 * m_radius * m_radius;
//    }
//private:
//    double m_x, m_y;
//    double m_radius;
//};
class IntArray 
{
private:
    int size;
    int *m_ptr;
public:
    IntArray(int sz)//构造函数
    {
        size = sz;
        m_ptr = new int[size];
    }
    IntArray()//构造函数
    {
        size = 10;
        m_ptr = new int[size];
    }
    //拷贝构造函数
    IntArray(IntArray &x)
    {
        size = x.size;
        m_ptr = new int[size];
    }
    //写入数据到数组指定位置
    void SetDate(int sz,int writedate)
    {
        *(m_ptr + sz) =  writedate;
    }
    //获取数组中制定位置的数据
    int getDate(int sz)
    {
        if (sz<size)
        {
            return *(m_ptr + sz);
        }
        else
        {
            return -1;
        }
    }
    void infoOfArray()//调用函数，输出函数信息
    {
        cout << "The size of Array is " << size << endl;
    }
    ~IntArray()//析构函数
    {
        delete[]m_ptr;//收回额外空间
    }
};

/*int main()
{
    Circle circleA, circleB(2, 2, 12.5);
    Circle* pCircle = &circleB;
    
    cout << "圆A的圆心为:("<<circleA.GetX()<<","<<circleA.GetY() <<")"<<endl;
    cout << "圆A的半径为:" << circleA.GetRadius() << endl;
    cout << "圆A的面积为:" << circleA.GetArea() << endl;
    //
    cout << "圆B的圆心为:(" << pCircle->GetX() << "," << pCircle->GetY() << ")" << endl;
    cout << "圆B的半径为:" << pCircle->GetRadius() << endl;
    cout << "圆B的面积为:" << pCircle->GetArea() << endl;
}*/
//int main()
//{
//    //类的接口调用
//    /*IntArray Array1;
//    int m = 99;
//    Array1.SetDate(1, m);
//    cout << Array1.getDate(10) << endl;*/
//    //Array1.infoOfArray();
//     
//    //自定义拷贝构造函数
//    IntArray s;
//    IntArray y(s);
//    y.infoOfArray();
//}


//int main()
//{
//    Circle A, B(10, 10, 3.5);
//    cout << A.GetArea() << endl;
//    cout << B.GetArea() << endl;
//    cout << A.GetNumber() << endl;
//    cout << B.getxy() << endl;
//}

void getStudentInfo(Student& s)
{
    cout << s.m_number << " " << s.m_name << " " << s.m_score << endl;
}
//int main()
//{
//
//    string mm;
//    Teacher t;
//    Manager m;
//    Student s;
//    t.SetScore(s, 85.5);
//    m.ModifyStudentInfo(s, 1201201, 'm', 95);
//    getStudentInfo(s);
//    return 0;
//}

//int main()
//{
//    Complex a1, a2(1, 2), a3(3, 4);
//    a1 = a2 + a3;
//    a1.Display();
//    //运算符重载函数的使用
//
//}

//int main()
//{
//    Student student;
//    Person person;
//    char SNO[8]="1212121";
//    student.SetSno(SNO);
//    
//    //student.SetName('小明');
//    cout << student.GetSno();
//    //类中的学号设置、名字设置、都有问题
//}

    //static int GetNum()
    //{
    //    return Num;
    //};
    //~battal()
    //{
    //     Num--;//累计定义的瓶个数
    //}

class A
{
private:
    const int a;
    int b;
public:
    /*friend int B::getValue(A& s);*/
    const int c;
    int getb() const//常量函数
    {
        return b;
    };
    A(const int x, int y, const int z):a(x),c(z)//列表初始化类中的常量成员
    {
        b = y;//普通成员变量直接赋值
    };
    int geta()
    {
        return a;
    };
    int getc()
    {
        return c;
    };
};
//class B
//{
//public:
//    int getValue(A& s)
//    {
//        return s.a;
//    };
//
//};

//构造函数和静态常量和静态常量函数
//int main()
//{
//    Battle NFbattal;
//    Battle YBbattal(2.0,3.0);
//    Battle* p = new Battle;//新建一个Battle的变量
//    cout << NFbattal.GetVoltage() <<";"<< YBbattal.GetVoltage() << endl;
//    cout << YBbattal.GetNum() << p->GetNum() << Battle::GetNum();
//}

double ReadSensorPar(Sensor_PH & m)
{
    return m.PH_par;
};



//int main()//常量使用
//{
//    A test1(10,20,30);
//    cout << test1.geta() << test1.getc()<<test1.getb();
//}

//int main()
//{
//    //Sensor_PH ph(6.86);
//
//    //cout << ReadSensorPar(ph)<<endl;//友元函数访问原函数
//    //cout << LQ.GetPar(ph) << endl;//友类中的成员函数访问原函数
//
//    //访问类中的类成员对象，无法访问私有，只能通过共有接口访问
//    /*const char* name = "龙泉试点";
//    Sensor_Sevpar LQ("longquan", 12.3);
//    cout << LQ.getname() << endl;*/
//}

 class  animal
{
public:
    int age=18;
    virtual void SpeakVoive()//定义虚函数，实现动态多态
    {
        cout << "动物在讲话" << endl;
    }
};
class Goat : virtual public animal//菱形继承中属性存在二义性，在第二层继承中采用虚继承方式
{
};
class Tuo :virtual public animal
{

};
class GoatTuo :public Goat, public Tuo
{
};

class Cat :public animal
{
public:
    //void SpeakVoive()
    //{
    //    cout << "猫在讲话" << endl;
    //}
};

int Getage(GoatTuo * s)
{
    return s->age;
}
template <class T> class Stack
{
private:
    vector<T> elems;
public:
    void push(T const&);
    void pop();//删除最后一个元素
    T top();// const;
    bool empty() const {
        return elems.empty();
    };

};
//实现
template <class T> void Stack<T>::push(T const& elem)
{
    elems.push_back(elem);
};
template <class T> void Stack<T>::pop()
{
    if (elems.empty())
    {
        throw out_of_range("Stack<>::pop(): empty stack");//显示提示空栈
    }
    elems.pop_back();
};
template <class T>
T Stack<T>::top()
{
    if (elems.empty()) {
        throw out_of_range("Stack<>::top(): empty stack");
    }
    // 返回最后一个元素的副本 
    return elems.back();
}

void test01()//写文本文件
{
    //1、包含fstream头文件
    //2、创建流对象
    ofstream outofs;
    //3、指定打开方式
    
    outofs.open("test.txt", ios::out);//没有指定文件，则创建文件
    //4、写入对象
    outofs << "姓名：张三" << endl;
    outofs << "年纪：18" << endl;
    outofs << "性别：男" << endl;
    //5、关闭流对象
    outofs.close();
}

void test02()//读文本文件
{
    //1、包含fstream头文件
    //2、创建流对象
    ifstream ifs;
    //3、指定打开方式
    ifs.open("test.txt", ios::in);
    //判断是否打开
    if (!ifs.is_open())
    {
        cout << "文件打开失败" << endl;
        return;
    }
    //4、读取对象
  /*  char buff[1024];
    while (ifs>>buff)
    {
        cout << buff << endl;
    }*/
    //char buff[1024];
    //while (ifs.getline(buff,sizeof(buff)))
    //{
    //    cout << buff << endl;
    //}

    string buff;
    while (getline(ifs, buff))
    {
        cout << buff << endl;
    }
    //5、关闭流对象
    ifs.close();
}
class perinfo
{
public:
    char m_name[64];
    int m_age;

};
void test03()//写二进制文件
{
    //1、fstream头文件
    //2、创建文件流对象
    ofstream ofs;
    //3、打开方式
    
    ofs.open("person.txt", ios::out | ios::binary);
    //4、写入对象
    perinfo per = {"张三",18 };
    ofs.write((const char*)&per, sizeof(per));
        //5、关闭流文件
        ofs.close();
};
void test04()//读二进制文件
{
    ifstream ifs;
    ifs.open("person.txt",ios::in| ios::binary);
    if (!ifs.is_open())
    {
        cout << "打开失败" << endl;
    }
    perinfo per;
    ifs.read((char*)&per, sizeof(ifs));
    cout << per.m_name << "\t";
    cout << per.m_age << endl;
}
//统计字符串中字符出现的次数
int StrNum(string m_str,char m_mark)
{
    int m_num=0;
    for (int i = 0; i < m_str.size(); i++)
    {
        if (m_str[i]==m_mark)
        {
            m_num++;
        }
    }
    return m_num;
}
bool Is_origin(string m_order)
{
    //U的判断
    int a = 0, b = 0;
    for (int i = 0; i < m_order.size(); i++)
    {
        if (m_order[i] == 'L') { a++; }
        if (m_order[i] == 'R') { a--; }
        if (m_order[i] == 'U') { b++; }
        if (m_order[i] == 'D') { b--; }
    }
    if (a==0&&b==0)
    {
        return true;
    }
    else
    {
        return false;
    }
};
vector<int> twoSum(vector<int>& nums, int target) {
    vector<int> ret;
    for (int i = 0; i < nums.size(); i++)
    {
        for (int j = i + 1; j < nums.size(); j++) {
            if (nums[i] + nums[j] == target){
            ret[0] = i;
            ret[1] = j;
            }
        }

    }
    return ret;
}
int climbStairs(int n) {
    if (n == 1)return 1;
    if (n == 2) return 2;
    int reslut = 0;
    int pre = 2;
    int prepre = 1;
    for (int i=3;i<=n;i++)
    {
        reslut = pre + prepre;
        prepre = pre;
        pre = reslut;
    }
    return reslut;
};
//int removeElement(vector<int>& nums,  int val) {
//    if (nums.size() == 0) { return 0; }
//   /*int i = 0;
//    for (int j = 0; j < nums.size(); j++)
//    {
//        if (nums[j] != val)
//        {
//            nums[i] = nums[j];
//            i++;
//        }
//
//    }
//    return i;*/
//    int j = 0;
//    for (int i = 0; i < nums.size(); i++) {
//        if (nums[i] != val) {
//            nums[j] = nums[i];
//            j++;
//        }
//    }
//    return j;
//}

int removeElement(vector<int>& nums, int val) {
    int slowIndex = 0;
    for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
        if (val != nums[fastIndex]) {
            nums[slowIndex++] = nums[fastIndex];
        }
    }
    return slowIndex;
}
struct tree
{
    int data;
    tree* left, * right;
};
/*

int main()
{
    //GoatTuo ss1;
   // Getage(&ss1);
    /*Cat cat;
    cat.SpeakVoive();

    //Stack<int> intstack;
    //intstack.push(3);
    //cout << intstack.top();


    //test01();
   //test02();
   // test03();
    //test04();
    //vector<int> tt = {1,2,3,4,5,6};
    //vector<int> ret = { 1,2,3,4,5,6 };
    //int i = 0, j = 0;
    //for (int i = 0; i < ret.size(); i++)
    //{
    //    for (int j = i + 1; j < ret.size(); j++) {
    //        if (ret[i] + ret[j] == 7) {

    //            break;
    //        }
    //    }

    //}
    //cout << ret.size()<<" "<< i << " " << j << endl;
    //cout << twoSum(tt,7)[0] << twoSum(tt, 7)[1] << endl;
    //cout<<climbStairs(10)<<endl;
    vector<int>::iterator it;// = vector<int>::begin();
    vector<int>v1 = { 11,2,5,3,5 };
    vector<int>v2 = {};
    for (it = v1.begin(); it != v1.end(); it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    cout << v1.size() << endl;

    removeElement(v1, 11);
   
    for (it= v1.begin();it!=v1.end();it++)
    {
        cout << *it << " ";
    }
    cout << endl;
    cout << v1.size() << endl;

    //for (it = v2.begin(); it != v2.end(); it++)
    //{
    //    cout << *it << " ";
    //}
    //cout << endl;
    //cout << v2.size() << endl;

}
*/

//******************************力扣代码学习***************

//1. 两数之和
vector<int> twoSum(vector<int>& nums, int target)
{
    int i, j;
    for (i = 0; i <nums.size()-1;i++)
    {
        
        for ( j = i+1; j < nums.size(); j++)
        {
            if (target ==nums[i]+nums[j])
            {
                return {i,j};
            }
        }
    }
    return { i,j };
}
//2. 回文数

bool isPalindrome(int x)
{

}



int main()
{

    for (size_t i = 0; i < 2; i++)
    {
        printf("hello world");
    }



}
